// axios实例工具类
import axios from 'axios';
import type { AxiosInstance, AxiosError } from 'axios';

// 基础API配置
// 1. 修改 API_CONFIG，移除 baseURL
const API_CONFIG = {
  baseURL: 'http://localhost:8899', 
  timeout: 10000,
  headers: {
    'Content-Type': 'application/json',
  },
  withCredentials: true,
};

/**
 * Axios实例管理类
 */
export class AxiosManager {  // 添加 export 关键字导出这个类
  // 基础axios实例
  private static baseInstance: AxiosInstance = axios.create(API_CONFIG);
  
  // 带认证的axios实例
  private static authInstance: AxiosInstance = axios.create(API_CONFIG);
  
  // 是否已设置认证拦截器
  private static authInterceptorSet = false;
  
  // 是否已设置响应拦截器
  private static responseInterceptorSet = false;

  /**
   * 获取基础axios实例（不带认证）
   */
  public static getBaseInstance(): AxiosInstance {
    return this.baseInstance;
  }

  /**
   * 获取带认证的axios实例
   */
  public static getAuthInstance(): AxiosInstance {
    // 确保认证拦截器已设置
    if (!this.authInterceptorSet) {
      this.setupAuthInterceptor();
    }
    
    // 确保响应拦截器已设置
    if (!this.responseInterceptorSet) {
      this.setupResponseInterceptor();
    }
    
    return this.authInstance;
  }

  /**
   * 设置认证拦截器
   */
  // 修改setupAuthInterceptor方法，增加详细日志
  private static setupAuthInterceptor(): void {
    this.authInstance.interceptors.request.use(
      (config) => {
        const token = this.getAuthToken();
        console.log(`[Axios拦截器] 请求URL: ${config.url}`);
        console.log(`[Axios拦截器] 获取的令牌: ${token || 'null'}`);
        
        if (token) {
          config.headers.Authorization = `Bearer ${token}`;
          console.log(`[Axios拦截器] 添加Authorization头部: Bearer ${token}`);
        } else {
          console.warn(`[Axios拦截器] 未找到认证令牌，请求未携带认证信息`);
        }
        
        // 添加跨域请求头
        config.headers['Access-Control-Allow-Origin'] = '*';
        return config;
      },
      (error) => {
        console.error('[Axios拦截器] 请求配置错误:', error);
        return Promise.reject(error);
      }
    );
    
    this.authInterceptorSet = true;
  }
  
  /**
   * 设置响应拦截器
   */
  private static setupResponseInterceptor(): void {
    this.authInstance.interceptors.response.use(
      (response) => response,
      (error: AxiosError) => {
        // 处理认证错误
        if (error.response?.status === 401 || error.response?.status === 403) {
          this.clearAuthData();
          // 避免无限重定向
          if (window.location.pathname !== '/login') {
            window.location.href = '/login';
          }
        }
        return Promise.reject(error);
      }
    );
    
    // 为基础实例也设置响应拦截器（用于处理非认证请求的错误）
    this.baseInstance.interceptors.response.use(
      (response) => response,
      (error) => {
        return Promise.reject(error);
      }
    );
    
    this.responseInterceptorSet = true;
  }

  /**
   * 保存认证令牌到本地存储
   */
  public static saveAuthToken(token: string): void {
    try {
      localStorage.setItem('Authorization', token);
    } catch (error) {
      console.error('保存认证令牌失败:', error);
    }
  }

  /**
   * 保存用户信息到本地存储
   */
  public static saveUserInfo(userInfo: any): void {
    try {
      localStorage.setItem('user_info', JSON.stringify(userInfo));
    } catch (error) {
      console.error('保存用户信息失败:', error);
    }
  }

  /**
   * 从本地存储获取认证令牌
   */
  public static getAuthToken(): string | null {
    try {
      return localStorage.getItem('Authorization');
    } catch (error) {
      console.error('获取认证令牌失败:', error);
      return null;
    }
  }

  /**
   * 从本地存储获取用户信息
   */
  public static getUserInfo<T = any>(): T | null {
    try {
      const userInfo = localStorage.getItem('user_info');
      return userInfo ? JSON.parse(userInfo) : null;
    } catch (error) {
      console.error('获取用户信息失败:', error);
      return null;
    }
  }

  /**
   * 清除本地存储中的认证信息
   */
  public static clearAuthData(): void {
    try {
      localStorage.removeItem('Authorization');
      localStorage.removeItem('user_info');
    } catch (error) {
      console.error('清除认证信息失败:', error);
    }
  }

  /**
   * 检查用户是否已登录
   */
  public static isAuthenticated(): boolean {
    return !!this.getAuthToken();
  }
}

/**
 * API响应接口 - 适配Java后端风格
 */
export interface ApiResponse<T = any> {
  code: string; // 状态码
  msg: string; // 消息
  data?: T; // 数据
}

/**
 * 判断API响应是否成功
 */
export const isResponseSuccess = (response: ApiResponse): boolean => {
  // 根据后端实际的成功状态码判断，这里假设'0'或'200'表示成功
  return response.code === '0' || response.code === '200';
};

/**
 * 处理API错误 - 适配Java后端风格
 */
export const handleApiError = (error: any, defaultMessage = '请求失败'): ApiResponse => {
  console.error('API请求错误:', error);
  
  if (axios.isAxiosError(error)) {
    if (error.response) {
      // 服务器返回了错误状态码
      return {
        code: error.response.status.toString(),
        msg: error.response.data?.msg || `${defaultMessage}: ${error.response.status} ${error.response.statusText}`,
      };
    } else if (error.request) {
      // 请求已发送但没有收到响应
      return {
        code: '500',
        msg: '网络错误，请检查您的网络连接',
      };
    } else {
      // 请求配置错误
      return {
        code: '400',
        msg: error.message || defaultMessage,
      };
    }
  } else {
    // 其他类型的错误
    return {
      code: '500',
      msg: error instanceof Error ? error.message : defaultMessage,
    };
  }
};

// 导出便捷的axios实例
export const baseAPI = AxiosManager.getBaseInstance();
export const authAPI = AxiosManager.getAuthInstance();


// 添加全局函数检查认证状态
/**
 * 检查并打印当前认证状态（用于调试）
 */
export const checkAuthStatus = (): void => {
  const token = AxiosManager.getAuthToken();
  const userInfo = AxiosManager.getUserInfo();
  const isAuthenticated = AxiosManager.isAuthenticated();
  
  console.log('=== 当前认证状态 ===');
  console.log('令牌存在:', !!token);
  console.log('令牌内容:', token);
  console.log('用户信息:', userInfo);
  console.log('是否已认证:', isAuthenticated);
  console.log('==================');
};
